/**
 * @desc 后台api统一管理
 */

import axios from "./axios";
import qs from "qs";
import devConfig from "*/dev.config";
// 设置 axios 请求体类型 (防止中文乱码)
axios.defaults.headers.post["Content-Type"] =
  "application/x-www-form-urlencoded; charset=UTF-8";

// 后台请求统一前缀，你可以根据需要用多种前缀区分不同类型的接口
const apiPrefix = devConfig.apiPrefix;
const apiPrefixImg = devConfig.apiPrefixImg;
// 模拟数据统一前缀，模拟数据的json文件统一放在项目的static/mock目录下
const mockPrefix = "/static/mock";
// 上传路径
export const uploadUrl = devConfig.apiPrefixUpload;
//推送路径
export const wssUrl = devConfig.apiPrefixWSS;

//富文本图片上传地址
// export const richImgURL = devConfig.ckeditorUpload

//本地存储key值
const localKeyData = {
  role: "sxgh_role", //登录人的角色
  loginPersonnelInformation: "sxgh_loginPersonnelInformation", //登录人信息localStorage存储
  user: "sxgh_user", //登录人信息session存储
  userID: "sxgh_userID", //登录人的userId
  menuActive: "sxgh_menuActive" //默认选中菜单
  // token: "" //时间戳token
};

// 集中管理Api
const Api = {
  //获取本地存储key值
  getLocalKey() {
    return localKeyData;
    // return "hhhh"
  },
  // 图片获取路径
  getImgUrl() {
    return apiPrefixImg;
  },
  // 获取上传路径
  getUploadUrl() {
    return uploadUrl;
  },
  // 获取推送路径
  getWssUrl() {
    return wssUrl;
  },
  // 按钮权限
  getqxbutton(reqData) {
    var user = JSON.parse(sessionStorage.getItem(localKeyData.user)).data
      .authority;
    var req = this.transpage(reqData);
    var userInfo = user.filter(ele => {
      if (ele.name == req) {
        return ele;
      }
    });

    var users = userInfo[0][req];
    var bottons = [];
    for (var item of users) {
      bottons.push(this.changbtn(item));
    }
    // console.log(users, bottons)
    return bottons;
  },

  //按钮名称替换
  changbtn(item) {
    var it = parseInt(item);
    switch (it) {
      case 1:
        return "新增";
        break;
      case 2:
        return "删除";
        break;
      case 3:
        return "修改";
        break;
      case 4:
        return "详情";
        break;
      case 5:
        return "修改权限";
        break;
      case 6:
        return "河流负责关系";
        break;
      case 9:
        return "下载历年预案模板";
        break;
      case 10:
        return "导入历年预案";
        break;
      case 11:
        return "通过";
        break;
      case 12:
        return "驳回";
        break;
      case 13:
        return "导出";
        break;
      case 14:
        return "领取";
        break;
      case 15:
        return "重新入库";
        break;
      case 16:
        return "注销";
        break;
      case 17:
        return "添加申请";
        break;
      case 18:
        return "支出";
        break;
      case 19:
        return "添加";
        break;
      case 20:
        return "列表";
        break;
      case 21:
        return "全景图";
        break;
      case 22:
        return "出借";
        break;
    }
  },

  //导航翻译
  translate(item) {
    var it = parseInt(item);
    switch (it) {
      case 1:
        return "县乡村管理";
        break;
      case 2:
        return "部门管理";
        break;
      case 3:
        return "岗位管理";
        break;
      case 4:
        return "角色管理";
        break;
      case 5:
        return "用户管理";
        break;
      case 6:
        return "河道管理";
        break;
      case 7:
        return "坑塘管理";
        break;
      case 8:
        return "水系连通工程";
        break;
      case 9:
        return "污水治理";
        break;
      case 10:
        return "生态治理";
        break;
      case 11:
        return "坑塘治理";
        break;
      case 12:
        return "乡村河渠生态绿化工程";
        break;
      case 13:
        return "工程划界";
        break;
      case 14:
        return "注册登记";
        break;
      case 15:
        return "培训管理";
        break;
      case 16:
        return "管理制度";
        break;
      case 17:
        return "经费管理";
        break;
      case 18:
        return "乡村河渠步行道工程";
        break;
      case 19:
        return "安全鉴定（评价）";
        break;
      case 20:
        return "除险加固";
        break;
      case 21:
        return "防汛物资审批";
        break;
      case 22:
        return "防汛物资管理";
        break;
      case 23:
        return "防汛物资分类";
        break;
      case 24:
        return "险情管理";
        break;
      case 25:
        return "工程巡查";
        break;
      case 26:
        return "安全检查";
        break;
      case 27:
        return "隐患管理";
        break;
      case 28:
        return "维修养护计划管理";
        break;
      case 29:
        return "日常养护";
        break;
      case 30:
        return "专项维养项目管理";
        break;
      case 31:
        return "经费统计分析";
        break;
      case 32:
        return "调度管理";
        break;
      case 33:
        return "两册一表";
        break;
      case 34:
        return "控制运行";
        break;
      case 35:
        return "设备分类";
        break;
      case 36:
        return "设备台账";
        break;
      case 37:
        return "预案管理";
        break;
      case 38:
        return "水库管理";
        break;
      case 39:
        return "自评指标";
        break;
      case 40:
        return "自评实施";
        break;
      case 41:
        return "自评问题管理";
        break;
      case 42:
        return "电子档案管理";
        break;
      case 43:
        return "纸质档案管理";
        break;
      case 44:
        return "分类管理";
        break;
      case 45:
        return "监测站点管理";
        break;
      case 46:
        return "监测站点类型";
        break;
      case 47:
        return "水位监测";
        break;
      case 48:
        return "流量监测";
        break;
      case 49:
        return "水质监测";
        break;
      case 50:
        return "雨量监测";
        break;
      case 51:
        return "运行监测";
        break;
      case 52:
        return "预警信息";
        break;
      case 53:
        return "值班信息";
        break;
      case 54:
        return "水美乡村片区提升工程";
        break;
      case 55:
        return "破损山体修复工程";
        break;
    }
  },
  // 页面对应
  transpage(item) {
    // var it = parseInt(item)
    switch (item) {
      case "县乡村管理":
        return "1";
        break;
      case "部门管理":
        return "2";
        break;
      case "岗位管理":
        return "3";
        break;
      case "角色管理":
        return "4";
        break;
      case "用户管理":
        return "5";
        break;
      case "河道管理":
        return "6";
        break;
      case "坑塘管理":
        return "7";
        break;
      case "水系连通工程":
        return "8";
        break;
      case "污水治理":
        return "9";
        break;
      case "生态治理":
        return "10";
        break;
      case "坑塘治理":
        return "11";
        break;
      case "乡村河渠生态绿化工程":
        return "12";
        break;
      case "工程划界":
        return "13";
        break;
      case "注册登记":
        return "14";
        break;
      case "培训管理":
        return "15";
        break;
      case "管理制度":
        return "16";
        break;
      case "经费管理":
        return "17";
        break;
      case "乡村河渠步行道工程":
        return "18";
        break;
      case "安全鉴定（评价）":
        return "19";
        break;
      case "除险加固":
        return "20";
        break;
      case "防汛物资审批":
        return "21";
        break;
      case "防汛物资管理":
        return "22";
        break;
      case "防汛物资分类":
        return "23";
        break;
      case "险情管理":
        return "24";
        break;
      case "工程巡查":
        return "25";
        break;
      case "安全检查":
        return "26";
        break;
      case "隐患管理":
        return "27";
        break;
      case "维修养护计划管理":
        return "28";
        break;
      case "日常养护":
        return "29";
        break;
      case "专项维养项目管理":
        return "30";
        break;
      case "经费统计分析":
        return "31";
        break;
      case "调度管理":
        return "32";
        break;
      case "两册一表":
        return "33";
        break;
      case "控制运行":
        return "34";
        break;
      case "设备分类":
        return "35";
        break;
      case "设备台账":
        return "36";
        break;
      case "预案管理":
        return "37";
        break;
      case "水库管理":
        return "38";
        break;
      case "自评指标":
        return "39";
        break;
      case "自评实施":
        return "40";
        break;
      case "自评问题管理":
        return "41";
        break;
      case "电子档案管理":
        return "42";
        break;
      case "纸质档案管理":
        return "43";
        break;
      case "分类管理":
        return "44";
        break;
      case "监测站点管理":
        return "45";
        break;
      case "监测站点类型":
        return "46";
        break;
      case "水位监测":
        return "47";
        break;
      case "流量监测":
        return "48";
        break;
      case "水质监测":
        return "49";
        break;
      case "雨量监测":
        return "50";
        break;
      case "运行监测":
        return "51";
        break;
      case "预警信息":
        return "52";
        break;
      case "值班信息":
        return "53";
        break;
      case "水美乡村片区提升工程":
        return "54";
        break;
      case "破损山体修复工程":
        return "55";
        break;
    }
  },

  // 登录接口
  doLogin(reqData) {
    // return axios.post(`${apiPrefix}/user/login`, qs.stringify(reqData))
    return axios.post(`${apiPrefix}/user/login`, qs.stringify(reqData));
  },
  // 退出登录
  logout() {
    // return axios.post(`${apiPrefix}/user/pc/logout`)
    return axios.post(`${apiPrefix}/user/pc/logout`, {});
  },

  /*  /!**
    * 管理员端
    * @returns {*}
    *!/

   // // 文件上传
   // fileUploadUrl() {
   // 	return uploadUrl + "/file/fileupload";
   // },
   // // 文件上传 FTP方式上传
   // fileUploadUrl2() {
   // 	return uploadUrl + "/file/fileupload3";
   // },
   // // 删除文件
   // filedelete(reqData) {
   // 	return axios.post(`${apiPrefix}/file/filedelete`, qs.stringify(reqData));
   // },

   //文件上传
   file_upload() {
     return uploadUrl + "/file/upload";
   },

   //培训纪录列表
   training_list(reqData) {
     return axios.post(`${apiPrefix}/training/list`, qs.stringify(reqData));
   },
   //培训纪录详情
   training_query(reqData) {
     return axios.post(`${apiPrefix}/training/query`, qs.stringify(reqData));
   },
   //培训纪录添加
   training_add(reqData) {
     return axios.post(`${apiPrefix}/training/add`, qs.stringify(reqData));
   },
   //培训纪录修改
   training_update(reqData) {
     return axios.post(`${apiPrefix}/training/update`, qs.stringify(reqData));
   },

   //培训纪录删除
   training_del(reqData) {
     return axios.post(`${apiPrefix}/training/del`, qs.stringify(reqData));
   },

   //河道列表
   river_list(reqData) {
     return axios.post(`${apiPrefix}/river/list`, qs.stringify(reqData));
   },
   //河道详情
   river_query(reqData) {
     return axios.post(`${apiPrefix}/river/query`, qs.stringify(reqData));
   },
   //河道添加
   river_add(reqData) {
     return axios.post(`${apiPrefix}/river/add`, qs.stringify(reqData));
   },
   //河道修改
   river_update(reqData) {
     return axios.post(`${apiPrefix}/river/update`, qs.stringify(reqData));
   },
   //河道删除
   river_del(reqData) {
     return axios.post(`${apiPrefix}/river/del`, qs.stringify(reqData));
   },
   //管理制度列表
   manage_list(reqData) {
     return axios.post(`${apiPrefix}/manage/list`, qs.stringify(reqData));
   },
   //管理制度详情
   manage_query(reqData) {
     return axios.post(`${apiPrefix}/manage/query`, qs.stringify(reqData));
   },
   //管理制度添加
   manage_add(reqData) {
     return axios.post(`${apiPrefix}/manage/add`, qs.stringify(reqData));
   },
   //管理制度删除
   manage_del(reqData) {
     return axios.post(`${apiPrefix}/manage/del`, qs.stringify(reqData));
   },
   //管理制度修改
   manage_update(reqData) {
     return axios.post(`${apiPrefix}/manage/update`, qs.stringify(reqData));
   },

   //县列表
   county_village_county_list(reqData) {
     return axios.post(
       `${apiPrefix}/county_village/county/list`,
       qs.stringify(reqData)
     );
   },
   //县/乡/村列表
   county_village_t_v_list(reqData) {
     return axios.post(
       `${apiPrefix}/county_village/t_v/list`,
       qs.stringify(reqData)
     );
   },
   //县/乡/村修改
   county_village_t_v_update(reqData) {
     return axios.post(
       `${apiPrefix}/county_village/t_v/update`,
       qs.stringify(reqData)
     );
   },
   //县/乡/村添加
   county_village_t_v_add(reqData) {
     return axios.post(
       `${apiPrefix}/county_village/t_v/add`,
       qs.stringify(reqData)
     );
   },
   //县/乡/村删除
   county_village_t_v_del(reqData) {
     return axios.post(
       `${apiPrefix}/county_village/t_v/del`,
       qs.stringify(reqData)
     );
   },
   //岗位管理
   jobs_list(reqData) {
     return axios.post(`${apiPrefix}/jobs/list`, qs.stringify(reqData));
   },
   //岗位添加
   jobs_add(reqData) {
     return axios.post(`${apiPrefix}/jobs/add`, qs.stringify(reqData));
   },
   //岗位修改
   jobs_update(reqData) {
     return axios.post(`${apiPrefix}/jobs/update`, qs.stringify(reqData));
   },
   //岗位删除
   jobs_del(reqData) {
     return axios.post(`${apiPrefix}/jobs/del`, qs.stringify(reqData));
   },
   //岗位详情
   jobs_query(reqData) {
     return axios.post(`${apiPrefix}/jobs/query`, qs.stringify(reqData));
   },
   //用户列表
   user_list(reqData) {
     return axios.post(`${apiPrefix}/user/list`, qs.stringify(reqData));
   },
   //用户添加
   user_add(reqData) {
     return axios.post(`${apiPrefix}/user/add`, qs.stringify(reqData));
   },
   //用户修改
   user_update(reqData) {
     return axios.post(`${apiPrefix}/user/update`, qs.stringify(reqData));
   },
   //用户删除
   user_del(reqData) {
     return axios.post(`${apiPrefix}/user/del`, qs.stringify(reqData));
   },
   //用户详情
   user_query(reqData) {
     return axios.post(`${apiPrefix}/user/query`, qs.stringify(reqData));
   },
   //用户添加河流负责关系
   relation_add(reqData) {
     return axios.post(
       `${apiPrefix}/user/river/relation_add`,
       qs.stringify(reqData)
     );
   },
   //用户删除河流负责关系
   relation_del(reqData) {
     return axios.post(
       `${apiPrefix}/user/river/relation_del`,
       qs.stringify(reqData)
     );
   },
   //用户河流负责关系列表
   relation_list(reqData) {
     return axios.post(
       `${apiPrefix}/user/river/relation_list`,
       qs.stringify(reqData)
     );
   },
   //角色新增
   user_role_add(reqData) {
     return axios.post(`${apiPrefix}/user_role/add`, qs.stringify(reqData));
   },
   //角色删除
   user_role_del(reqData) {
     return axios.post(`${apiPrefix}/user_role/del`, qs.stringify(reqData));
   },
   //角色修改
   user_role_update(reqData) {
     return axios.post(`${apiPrefix}/user_role/update`, qs.stringify(reqData));
   },
   //角色列表
   user_role_list(reqData) {
     return axios.post(`${apiPrefix}/user_role/list`, qs.stringify(reqData));
   },

   //部门列表
   department_list(reqData) {
     return axios.post(`${apiPrefix}/department/list`, qs.stringify(reqData));
   },
   //部门新增
   department_add(reqData) {
     return axios.post(`${apiPrefix}/department/add`, qs.stringify(reqData));
   },
   //部门删除
   department_del(reqData) {
     return axios.post(`${apiPrefix}/department/del`, qs.stringify(reqData));
   },
   //部门详情
   department_query(reqData) {
     return axios.post(`${apiPrefix}/department/query`, qs.stringify(reqData));
   },
   //部门更新
   department_update(reqData) {
     return axios.post(`${apiPrefix}/department/update`, qs.stringify(reqData));
   },

   //水系连通列表
   wsc_list(reqData) {
     return axios.post(`${apiPrefix}/wsc/list`, qs.stringify(reqData));
   },
   //添加水系连通记录
   wsc_add(reqData) {
     return axios.post(`${apiPrefix}/wsc/add`, qs.stringify(reqData));
   },
   //删除水系连通记录
   wsc_del(reqData) {
     return axios.post(`${apiPrefix}/wsc/del`, qs.stringify(reqData));
   },
   //水系连通详情
   wsc_query(reqData) {
     return axios.post(`${apiPrefix}/wsc/query`, qs.stringify(reqData));
   },
   //修改水系连通记录
   wsc_update(reqData) {
     return axios.post(`${apiPrefix}/wsc/update`, qs.stringify(reqData));
   },

   // 村庄列表
   village_list(reqData) {
     return axios.post(
       `${apiPrefix}/county_village/village/list`,
       qs.stringify(reqData)
     );
   },
   //坑塘记录列表
   pond_list(reqData) {
     return axios.post(`${apiPrefix}/pond/list`, qs.stringify(reqData));
   },
   //添加坑塘记录
   pond_add(reqData) {
     return axios.post(`${apiPrefix}/pond/add`, qs.stringify(reqData));
   },
   //删除坑塘记录
   pond_del(reqData) {
     return axios.post(`${apiPrefix}/pond/del`, qs.stringify(reqData));
   },
   //坑塘记录详情
   pond_query(reqData) {
     return axios.post(`${apiPrefix}/pond/query`, qs.stringify(reqData));
   },
   //修改坑塘记录
   pond_update(reqData) {
     return axios.post(`${apiPrefix}/pond/update`, qs.stringify(reqData));
   },
   //坑塘记录工程列表
   pond_pro_list(reqData) {
     return axios.post(`${apiPrefix}/pond/pro/list`, qs.stringify(reqData));
   },
   //添加坑塘工程记录
   pond_pro_add(reqData) {
     return axios.post(`${apiPrefix}/pond/pro/add`, qs.stringify(reqData));
   },
   //删除坑塘工程记录
   pond_pro_del(reqData) {
     return axios.post(`${apiPrefix}/pond/pro/del`, qs.stringify(reqData));
   },
   //坑塘工程记录详情
   pond_pro_query(reqData) {
     return axios.post(`${apiPrefix}/pond/pro/query`, qs.stringify(reqData));
   },
   //修改坑塘工程记录
   pond_pro_update(reqData) {
     return axios.post(`${apiPrefix}/pond/pro/update`, qs.stringify(reqData));
   },
   //经费记录列表
   funds_list(reqData) {
     return axios.post(`${apiPrefix}/funds/list`, qs.stringify(reqData));
   },
   //经费记录添加
   funds_add(reqData) {
     return axios.post(`${apiPrefix}/funds/add`, qs.stringify(reqData));
   },
   //经费记录修改
   funds_update(reqData) {
     return axios.post(`${apiPrefix}/funds/update`, qs.stringify(reqData));
   },
   //经费记录删除
   funds_del(reqData) {
     return axios.post(`${apiPrefix}/funds/del`, qs.stringify(reqData));
   },
   //经费记录详情
   funds_query(reqData) {
     return axios.post(`${apiPrefix}/funds/query`, qs.stringify(reqData));
   },
   //经费记录列表
   funds_type_list(reqData) {
     return axios.post(`${apiPrefix}/funds/type/list`, qs.stringify(reqData));
   },
   //权限列表
   jobs_menu_list(reqData) {
     return axios.post(`${apiPrefix}/jobs/menu/list`, qs.stringify(reqData));
   },
   //权限添加
   jobs_menu_update(reqData) {
     return axios.post(`${apiPrefix}/jobs/menu/update`, qs.stringify(reqData));
   },
   //县乡村
   county_village_xxc_list(reqData) {
     return axios.post(
       `${apiPrefix}/county_village/xxc/list`,
       qs.stringify(reqData)
     );
   },
   //污水治理列表
   sewage_list(reqData) {
     return axios.post(`${apiPrefix}/sewage/list`, qs.stringify(reqData));
   },
   //污水治理列表2
   list_township(reqData) {
     return axios.post(
       `${apiPrefix}/sewage/list/township`,
       qs.stringify(reqData)
     );
   },
   //污水治理详情
   sewage_query(reqData) {
     return axios.post(`${apiPrefix}/sewage/query`, qs.stringify(reqData));
   },
   //污水治理添加
   sewage_add(reqData) {
     return axios.post(`${apiPrefix}/sewage/add`, qs.stringify(reqData));
   },
   //污水治理修改
   sewage_update(reqData) {
     return axios.post(`${apiPrefix}/sewage/update`, qs.stringify(reqData));
   },
   //污水治理删除
   sewage_del(reqData) {
     return axios.post(`${apiPrefix}/sewage/del`, qs.stringify(reqData));
   },

   // 生态绿化 -- 水美乡村河渠生态绿化与步行道工程
   // 下拉的河道列表
   river_river_list(reqData) {
     return axios.post(`${apiPrefix}/river/river_list`, qs.stringify(reqData));
   },
   // 村河渠生态绿化与步行道工程列表
   grp_list(reqData) {
     return axios.post(`${apiPrefix}/grp/list`, qs.stringify(reqData));
   },
   // 村河渠生态绿化与步行道工程详情
   grp_query(reqData) {
     return axios.post(`${apiPrefix}/grp/query`, qs.stringify(reqData));
   },
   // 添加村河渠生态绿化与步行道工程记录
   grp_add(reqData) {
     return axios.post(`${apiPrefix}/grp/add`, qs.stringify(reqData));
   },
   // 修改村河渠生态绿化与步行道工程记录
   grp_update(reqData) {
     return axios.post(`${apiPrefix}/grp/update`, qs.stringify(reqData));
   },
   // 删除村河渠生态绿化与步行道工程记录
   grp_del(reqData) {
     return axios.post(`${apiPrefix}/grp/del`, qs.stringify(reqData));
   },

   // 工程管理-工程划界
   // 工程划界列表
   delimit_list(reqData) {
     return axios.post(`${apiPrefix}/delimit/list`, qs.stringify(reqData));
   },
   // 工程划界详情
   delimit_query(reqData) {
     return axios.post(`${apiPrefix}/delimit/query`, qs.stringify(reqData));
   },
   // 添加工程划界记录
   delimit_add(reqData) {
     return axios.post(`${apiPrefix}/delimit/add`, qs.stringify(reqData));
   },
   // 修改工程划界记
   delimit_update(reqData) {
     return axios.post(`${apiPrefix}/delimit/update`, qs.stringify(reqData));
   },
   // 删除工程划界记录
   delimit_del(reqData) {
     return axios.post(`${apiPrefix}/delimit/del`, qs.stringify(reqData));
   },

   // 工程管理-注册登记
   // 注册登记列表
   regis_list(reqData) {
     return axios.post(`${apiPrefix}/regis/list`, qs.stringify(reqData));
   },
   // 注册登记详情
   regis_query(reqData) {
     return axios.post(`${apiPrefix}/regis/query`, qs.stringify(reqData));
   },
   // 添加注册登记记录
   regis_add(reqData) {
     return axios.post(`${apiPrefix}/regis/add`, qs.stringify(reqData));
   },
   // 修改注册登记记录
   regis_update(reqData) {
     return axios.post(`${apiPrefix}/regis/update`, qs.stringify(reqData));
   },
   // 删除注册登记记录
   regis_del(reqData) {
     return axios.post(`${apiPrefix}/regis/del`, qs.stringify(reqData));
   },
   // 生态治理列表
   rec_list(reqData) {
     return axios.post(`${apiPrefix}/rec/list`, qs.stringify(reqData));
   },
   // 生态治理详情
   rec_query(reqData) {
     return axios.post(`${apiPrefix}/rec/query`, qs.stringify(reqData));
   },
   // 生态治理添加
   rec_add(reqData) {
     return axios.post(`${apiPrefix}/rec/add`, qs.stringify(reqData));
   },
   // 生态治理修改
   rec_update(reqData) {
     return axios.post(`${apiPrefix}/rec/update`, qs.stringify(reqData));
   },
   // 生态治理删除
   rec_del(reqData) {
     return axios.post(`${apiPrefix}/rec/del`, qs.stringify(reqData));
   },
   // 生态治理统计
   rec_listall(reqData) {
     return axios.post(`${apiPrefix}/rec/listall`, qs.stringify(reqData));
   },
   // // 权限列表
   user_role_menu_list(reqData) {
     return axios.post(
       `${apiPrefix}/user_role/menu/list`,
       qs.stringify(reqData)
     );
   },
   // // 权限修改
   user_role_menu_update(reqData) {
     return axios.post(
       `${apiPrefix}/user_role/menu/update`,
       qs.stringify(reqData)
     );
   },
   // 角色列表
   user_role_list_all(reqData) {
     return axios.post(`${apiPrefix}/user_role/list/all`, qs.stringify(reqData));
   },
   // 全景图
   // 点位列表
   panorama_point_list(reqData) {
     return axios.post(
       `${apiPrefix}/panorama/point/list`,
       qs.stringify(reqData)
     );
   },
   // 点位详情
   panorama_point_query(reqData) {
     return axios.post(
       `${apiPrefix}/panorama/point/query`,
       qs.stringify(reqData)
     );
   },
   // 点位修改
   panorama_point_update(reqData) {
     return axios.post(
       `${apiPrefix}/panorama/point/update`,
       qs.stringify(reqData)
     );
   },
   // 点位添加
   panorama_point_add(reqData) {
     return axios.post(`${apiPrefix}/panorama/point/add`, qs.stringify(reqData));
   },
   // 点位删除
   panorama_point_del(reqData) {
     return axios.post(`${apiPrefix}/panorama/point/del`, qs.stringify(reqData));
   },
   // 全景图添加
   panorama_add(reqData) {
     return axios.post(`${apiPrefix}/panorama/add`, qs.stringify(reqData));
   },
   // 全景图修改
   panorama_update(reqData) {
     return axios.post(`${apiPrefix}/panorama/update`, qs.stringify(reqData));
   },
   // 状态修改
   user_update_state(reqData) {
     return axios.post(`${apiPrefix}/user/update/state`, qs.stringify(reqData));
   },
   // 用户密码修改
   user_update_account(reqData) {
     return axios.post(
       `${apiPrefix}/user/update/account`,
       qs.stringify(reqData)
     );
   },
   // 安全鉴定列表
   safety_appraisal_list(reqData) {
     return axios.post(
       `${apiPrefix}/safety_appraisal/list`,
       qs.stringify(reqData)
     );
   },
   // 安全鉴定添加
   safety_appraisal_add(reqData) {
     return axios.post(
       `${apiPrefix}/safety_appraisal/add`,
       qs.stringify(reqData)
     );
   },
   // 安全鉴定修改
   safety_appraisal_update(reqData) {
     return axios.post(
       `${apiPrefix}/safety_appraisal/update`,
       qs.stringify(reqData)
     );
   },
   // 安全鉴定详情
   safety_appraisal_query(reqData) {
     return axios.post(
       `${apiPrefix}/safety_appraisal/query`,
       qs.stringify(reqData)
     );
   },
   // 安全鉴定删除
   safety_appraisal_del(reqData) {
     return axios.post(
       `${apiPrefix}/safety_appraisal/del`,
       qs.stringify(reqData)
     );
   },
   // 水库管理列表
   reservoir_list(reqData) {
     return axios.post(`${apiPrefix}/reservoir/list`, qs.stringify(reqData));
   },
   // 水库管理删除
   reservoir_del(reqData) {
     return axios.post(`${apiPrefix}/reservoir/del`, qs.stringify(reqData));
   },
   // 水库管理添加
   reservoir_add(reqData) {
     return axios.post(`${apiPrefix}/reservoir/add`, qs.stringify(reqData));
   },
   // 水库管理修改
   reservoir_update(reqData) {
     return axios.post(`${apiPrefix}/reservoir/update`, qs.stringify(reqData));
   },
   // 水库管理详情
   reservoir_query(reqData) {
     return axios.post(`${apiPrefix}/reservoir/query`, qs.stringify(reqData));
   },
   // 工程管理
   project_list(reqData) {
     return axios.post(`${apiPrefix}/project/list`, qs.stringify(reqData));
   },
   // 除险加固列表
   reinforcement_list(reqData) {
     return axios.post(`${apiPrefix}/reinforcement/list`, qs.stringify(reqData));
   },
   // 除险加固详情
   reinforcement_query(reqData) {
     return axios.post(
       `${apiPrefix}/reinforcement/query`,
       qs.stringify(reqData)
     );
   },
   // 除险加固添加
   reinforcement_add(reqData) {
     return axios.post(`${apiPrefix}/reinforcement/add`, qs.stringify(reqData));
   },
   // 除险加固修改
   reinforcement_update(reqData) {
     return axios.post(
       `${apiPrefix}/reinforcement/update`,
       qs.stringify(reqData)
     );
   },
   // 除险加固删除
   reinforcement_del(reqData) {
     return axios.post(`${apiPrefix}/reinforcement/del`, qs.stringify(reqData));
   },
   // 审批添加
   audit_add(reqData) {
     return axios.post(`${apiPrefix}/audit/add`, qs.stringify(reqData));
   },
   // 审批更新
   audit_update(reqData) {
     return axios.post(`${apiPrefix}/audit/update`, qs.stringify(reqData));
   },
   // 预案列表
   plan_management_list(reqData) {
     return axios.post(
       `${apiPrefix}/plan_management/list`,
       qs.stringify(reqData)
     );
   },
   // 预案详情
   plan_management_query(reqData) {
     return axios.post(
       `${apiPrefix}/plan_management/query`,
       qs.stringify(reqData)
     );
   },
   // 预案添加
   plan_management_add(reqData) {
     return axios.post(
       `${apiPrefix}/plan_management/add`,
       qs.stringify(reqData)
     );
   },
   // 预案修改
   plan_management_update(reqData) {
     return axios.post(
       `${apiPrefix}/plan_management/update`,
       qs.stringify(reqData)
     );
   },
   // 预案删除
   plan_management_del(reqData) {
     return axios.post(
       `${apiPrefix}/plan_management/del`,
       qs.stringify(reqData)
     );
   },
   // 预案上传
   plan_management_import(reqData) {
     return axios.post(
       `${apiPrefix}/plan_management/import`,
       qs.stringify(reqData)
     );
   },
   // 防汛物资列表
   flood_materials_list(reqData) {
     return axios.post(
       `${apiPrefix}/flood_materials/list`,
       qs.stringify(reqData)
     );
   },
   // 防汛物资详情
   flood_materials_query(reqData) {
     return axios.post(
       `${apiPrefix}/flood_materials/query`,
       qs.stringify(reqData)
     );
   },
   // 防汛物资添加
   flood_materials_add(reqData) {
     return axios.post(
       `${apiPrefix}/flood_materials/add`,
       qs.stringify(reqData)
     );
   },
   // 防汛物资修改
   flood_materials_update(reqData) {
     return axios.post(
       `${apiPrefix}/flood_materials/update`,
       qs.stringify(reqData)
     );
   },
   // 防汛物资删除
   flood_materials_del(reqData) {
     return axios.post(
       `${apiPrefix}/flood_materials/del`,
       qs.stringify(reqData)
     );
   },
   // 防汛状态更新
   flood_materials_update_state(reqData) {
     return axios.post(
       `${apiPrefix}/flood_materials/update/state`,
       qs.stringify(reqData)
     );
   },
   // 防汛存量更新
   flood_materials_update_stock(reqData) {
     return axios.post(
       `${apiPrefix}/flood_materials/update/stock`,
       qs.stringify(reqData)
     );
   },
   // 防汛管理详情
   flood_materials_query_manager(reqData) {
     return axios.post(
       `${apiPrefix}/flood_materials/query/manager`,
       qs.stringify(reqData)
     );
   },
   // 防汛类型列表
   flood_materials_type_list(reqData) {
     return axios.post(
       `${apiPrefix}/flood_materials/type/list`,
       qs.stringify(reqData)
     );
   },
   // 防汛类型详情
   flood_materials_type_query(reqData) {
     return axios.post(
       `${apiPrefix}/flood_materials/type/query`,
       qs.stringify(reqData)
     );
   },
   // 防汛类型添加
   flood_materials_type_add(reqData) {
     return axios.post(
       `${apiPrefix}/flood_materials/type/add`,
       qs.stringify(reqData)
     );
   },
   // 防汛类型修改
   flood_materials_type_update(reqData) {
     return axios.post(
       `${apiPrefix}/flood_materials/type/update`,
       qs.stringify(reqData)
     );
   },
   // 防汛类型删除
   flood_materials_type_del(reqData) {
     return axios.post(
       `${apiPrefix}/flood_materials/type/del`,
       qs.stringify(reqData)
     );
   },
   // 险情管理列表
   danger_management_list(reqData) {
     return axios.post(
       `${apiPrefix}/danger_management/list`,
       qs.stringify(reqData)
     );
   },
   // 险情管理详情
   danger_management_query(reqData) {
     return axios.post(
       `${apiPrefix}/danger_management/query`,
       qs.stringify(reqData)
     );
   },
   // 险情管理添加
   danger_management_add(reqData) {
     return axios.post(
       `${apiPrefix}/danger_management/add`,
       qs.stringify(reqData)
     );
   },
   // 险情管理修改
   danger_management_update(reqData) {
     return axios.post(
       `${apiPrefix}/danger_management/update`,
       qs.stringify(reqData)
     );
   },
   // 险情管理删除
   danger_management_del(reqData) {
     return axios.post(
       `${apiPrefix}/danger_management/del`,
       qs.stringify(reqData)
     );
   },
   // 隐患管理列表
   applet_danger_list(reqData) {
     return axios.post(`${apiPrefix}/applet/danger/list`, qs.stringify(reqData));
   },
   // 隐患管理详情
   applet_danger_query(reqData) {
     return axios.post(
       `${apiPrefix}/applet/danger/query`,
       qs.stringify(reqData)
     );
   },

   // 控制运行计划
   // 控制运行计划列表
   operation_plan_list(reqData) {
     return axios.post(
       `${apiPrefix}/operation_plan/list`,
       qs.stringify(reqData)
     );
   },
   // 控制运行计划添加
   operation_plan_add(reqData) {
     return axios.post(`${apiPrefix}/operation_plan/add`, qs.stringify(reqData));
   },
   // 控制运行计划修改
   operation_plan_update(reqData) {
     return axios.post(
       `${apiPrefix}/operation_plan/update`,
       qs.stringify(reqData)
     );
   },
   // 控制运行计划删除
   operation_plan_del(reqData) {
     return axios.post(`${apiPrefix}/operation_plan/del`, qs.stringify(reqData));
   },
   // 控制运行计划详情
   operation_plan_query(reqData) {
     return axios.post(
       `${apiPrefix}/operation_plan/query`,
       qs.stringify(reqData)
     );
   },

   // 两册一表
   // 两册一表列表
   document_management_list(reqData) {
     return axios.post(
       `${apiPrefix}/document_management/list`,
       qs.stringify(reqData)
     );
   },
   // 两册一表添加
   document_management_add(reqData) {
     return axios.post(
       `${apiPrefix}/document_management/add`,
       qs.stringify(reqData)
     );
   },
   // 两册一表修改
   document_management_update(reqData) {
     return axios.post(
       `${apiPrefix}/document_management/update`,
       qs.stringify(reqData)
     );
   },
   // 两册一表删除
   document_management_del(reqData) {
     return axios.post(
       `${apiPrefix}/document_management/del`,
       qs.stringify(reqData)
     );
   },
   // 两册一表详情
   document_management_query(reqData) {
     return axios.post(
       `${apiPrefix}/document_management/query`,
       qs.stringify(reqData)
     );
   },
   // 设备管理
   // 设备分类
   // 设备分类列表
   equipment_type_list(reqData) {
     return axios.post(
       `${apiPrefix}/equipment_type/list`,
       qs.stringify(reqData)
     );
   },
   // 设备分类添加
   equipment_type_add(reqData) {
     return axios.post(`${apiPrefix}/equipment_type/add`, qs.stringify(reqData));
   },
   // 设备分类修改
   equipment_type_update(reqData) {
     return axios.post(
       `${apiPrefix}/equipment_type/update`,
       qs.stringify(reqData)
     );
   },
   // 设备分类删除
   equipment_type_del(reqData) {
     return axios.post(`${apiPrefix}/equipment_type/del`, qs.stringify(reqData));
   },
   // 设备分类详情
   equipment_type_query(reqData) {
     return axios.post(
       `${apiPrefix}/equipment_type/query`,
       qs.stringify(reqData)
     );
   },
   // 设备台账
   // 设备台账列表
   equipment_list(reqData) {
     return axios.post(`${apiPrefix}/equipment/list`, qs.stringify(reqData));
   },
   // 设备台账添加
   equipment_add(reqData) {
     return axios.post(`${apiPrefix}/equipment/add`, qs.stringify(reqData));
   },
   // 设备台账修改
   equipment_update(reqData) {
     return axios.post(`${apiPrefix}/equipment/update`, qs.stringify(reqData));
   },
   // 设备台账删除
   equipment_del(reqData) {
     return axios.post(`${apiPrefix}/equipment/del`, qs.stringify(reqData));
   },
   // 设备台账详情
   equipment_query(reqData) {
     return axios.post(`${apiPrefix}/equipment/query`, qs.stringify(reqData));
   },
   // 河流列表
   equipment_river_list(reqData) {
     return axios.post(`${apiPrefix}/river/river_list`, qs.stringify(reqData));
   },
   // 水库列表
   equipment_reservoir_list(reqData) {
     return axios.post(
       `${apiPrefix}/reservoir/reservoir_list`,
       qs.stringify(reqData)
     );
   },

   // 运行管理 调度管理
   // 调度管理列表
   scheduling_task_list(reqData) {
     return axios.post(
       `${apiPrefix}/scheduling_task/list`,
       qs.stringify(reqData)
     );
   },
   // 调度管理详情
   scheduling_task_query(reqData) {
     return axios.post(
       `${apiPrefix}/scheduling_task/query`,
       qs.stringify(reqData)
     );
   },
   // 安全检查列表
   safety_check_list(reqData) {
     return axios.post(`${apiPrefix}/safety_check/list`, qs.stringify(reqData));
   },
   // 安全检查详情
   safety_check_query(reqData) {
     return axios.post(`${apiPrefix}/safety_check/query`, qs.stringify(reqData));
   },
   // 安全检查添加
   safety_check_add(reqData) {
     return axios.post(`${apiPrefix}/safety_check/add`, qs.stringify(reqData));
   },
   // 安全检查修改
   safety_check_update(reqData) {
     return axios.post(
       `${apiPrefix}/safety_check/update`,
       qs.stringify(reqData)
     );
   },
   // 安全检查删除
   safety_check_del(reqData) {
     return axios.post(`${apiPrefix}/safety_check/del`, qs.stringify(reqData));
   },

   // 运行管理 维修养护 经费统计分析
   // 经费统计分析列表
   appropriation_management_list(reqData) {
     return axios.post(
       `${apiPrefix}/appropriation_management/list`,
       qs.stringify(reqData)
     );
   },
   // 经费统计分析详情
   appropriation_management_query(reqData) {
     return axios.post(
       `${apiPrefix}/appropriation_management/query`,
       qs.stringify(reqData)
     );
   },
   // 经费统计分析添加
   appropriation_management_add(reqData) {
     return axios.post(
       `${apiPrefix}/appropriation_management/add`,
       qs.stringify(reqData)
     );
   },
   // 经费统计分析修改
   appropriation_management_update(reqData) {
     return axios.post(
       `${apiPrefix}/appropriation_management/update`,
       qs.stringify(reqData)
     );
   },
   // 经费统计分析删除
   appropriation_management_del(reqData) {
     return axios.post(
       `${apiPrefix}/appropriation_management/del`,
       qs.stringify(reqData)
     );
   },
   // 经费统计分析支出经费
   appropriation_management_expenditure(reqData) {
     return axios.post(
       `${apiPrefix}/appropriation_management/expenditure`,
       qs.stringify(reqData)
     );
   },
   // 图表
   appropriation_management_chart(reqData) {
     return axios.post(
       `${apiPrefix}/appropriation_management/chart`,
       qs.stringify(reqData)
     );
   },
   // 运行管理 维修养护 专项维养项目管理
   // 专项维养项目管理列表
   special_maintenance_list(reqData) {
     return axios.post(
       `${apiPrefix}/special_maintenance/list`,
       qs.stringify(reqData)
     );
   },
   // 专项维养项目管理详情
   special_maintenance_query(reqData) {
     return axios.post(
       `${apiPrefix}/special_maintenance/query`,
       qs.stringify(reqData)
     );
   },
   // 专项维养项目管理添加
   special_maintenance_add(reqData) {
     return axios.post(
       `${apiPrefix}/special_maintenance/add`,
       qs.stringify(reqData)
     );
   },
   // 专项维养项目管理修改
   special_maintenance_update(reqData) {
     return axios.post(
       `${apiPrefix}/special_maintenance/update`,
       qs.stringify(reqData)
     );
   },
   // 专项维养项目管理删除
   special_maintenance_del(reqData) {
     return axios.post(
       `${apiPrefix}/special_maintenance/del`,
       qs.stringify(reqData)
     );
   },

   // 工程巡查列表
   patrol_task_list(reqData) {
     return axios.post(`${apiPrefix}/patrol/task/list`, qs.stringify(reqData));
   },
   // 工程巡查详情
   patrol_task_query(reqData) {
     return axios.post(`${apiPrefix}/patrol/task/query`, qs.stringify(reqData));
   },
   // 养护计划列表
   maintenance_plan_list(reqData) {
     return axios.post(
       `${apiPrefix}/maintenance_plan/list`,
       qs.stringify(reqData)
     );
   },
   // 养护计划详情
   maintenance_plan_query(reqData) {
     return axios.post(
       `${apiPrefix}/maintenance_plan/query`,
       qs.stringify(reqData)
     );
   },
   // 养护计划添加
   maintenance_plan_add(reqData) {
     return axios.post(
       `${apiPrefix}/maintenance_plan/add`,
       qs.stringify(reqData)
     );
   },
   // 养护计划修改
   maintenance_plan_update(reqData) {
     return axios.post(
       `${apiPrefix}/maintenance_plan/update`,
       qs.stringify(reqData)
     );
   },
   // 养护计划删除
   maintenance_plan_del(reqData) {
     return axios.post(
       `${apiPrefix}/maintenance_plan/del`,
       qs.stringify(reqData)
     );
   },
   // 日常养护列表
   rountine_list(reqData) {
     return axios.post(`${apiPrefix}/rountine/list`, qs.stringify(reqData));
   },
   // 日常养护详情
   rountine_query(reqData) {
     return axios.post(`${apiPrefix}/rountine/query`, qs.stringify(reqData));
   },
   // 日常养护添加
   rountine_add(reqData) {
     return axios.post(`${apiPrefix}/rountine/add`, qs.stringify(reqData));
   },
   // 日常养护修改
   rountine_update(reqData) {
     return axios.post(`${apiPrefix}/rountine/update`, qs.stringify(reqData));
   },
   // 日常养护删除
   rountine_del(reqData) {
     return axios.post(`${apiPrefix}/rountine/del`, qs.stringify(reqData));
   },
   // 日常养护维养计划列表
   rountine_plan_list(reqData) {
     return axios.post(`${apiPrefix}/rountine/plan/list`, qs.stringify(reqData));
   },
   // 日常养护维养计划增加
   rountine_plan_add(reqData) {
     return axios.post(`${apiPrefix}/rountine/plan/add`, qs.stringify(reqData));
   },
   // 日常养护维养计划修改
   rountine_plan_update(reqData) {
     return axios.post(
       `${apiPrefix}/rountine/plan/update`,
       qs.stringify(reqData)
     );
   },
   // 日常养护维养计划删除
   rountine_plan_del(reqData) {
     return axios.post(`${apiPrefix}/rountine/plan/del`, qs.stringify(reqData));
   },
   // 日常养护问题列表
   rountine_question_list(reqData) {
     return axios.post(
       `${apiPrefix}/rountine/question/list`,
       qs.stringify(reqData)
     );
   },
   // 日常养护问题增加
   rountine_question_add(reqData) {
     return axios.post(
       `${apiPrefix}/rountine/question/add`,
       qs.stringify(reqData)
     );
   },
   // 日常养护问题修改
   rountine_question_update(reqData) {
     return axios.post(
       `${apiPrefix}/rountine/question/update`,
       qs.stringify(reqData)
     );
   },
   // 日常养护问题删除
   rountine_question_del(reqData) {
     return axios.post(
       `${apiPrefix}/rountine/question/del`,
       qs.stringify(reqData)
     );
   },
   // 完成任务
   rountine_finish(reqData) {
     return axios.post(`${apiPrefix}/rountine/finish`, qs.stringify(reqData));
   },
   // 自评指标列表
   self_evaluation_index_list(reqData) {
     return axios.post(
       `${apiPrefix}/self_evaluation_index/list`,
       qs.stringify(reqData)
     );
   },
   // 自评指标详情
   self_evaluation_index_query(reqData) {
     return axios.post(
       `${apiPrefix}/self_evaluation_index/query`,
       qs.stringify(reqData)
     );
   },
   // 自评指标添加
   self_evaluation_index_add(reqData) {
     return axios.post(
       `${apiPrefix}/self_evaluation_index/add`,
       qs.stringify(reqData)
     );
   },
   // 自评指标修改
   self_evaluation_index_update(reqData) {
     return axios.post(
       `${apiPrefix}/self_evaluation_index/update`,
       qs.stringify(reqData)
     );
   },
   // 自评指标删除
   self_evaluation_index_del(reqData) {
     return axios.post(
       `${apiPrefix}/self_evaluation_index/del`,
       qs.stringify(reqData)
     );
   },
   // 自评实施列表
   self_evaluation_implement_list(reqData) {
     return axios.post(
       `${apiPrefix}/self_evaluation_implement/list`,
       qs.stringify(reqData)
     );
   },
   // 自评实施详情
   self_evaluation_implement_query(reqData) {
     return axios.post(
       `${apiPrefix}/self_evaluation_implement/query`,
       qs.stringify(reqData)
     );
   },
   // 自评实施添加
   self_evaluation_implement_add(reqData) {
     return axios.post(
       `${apiPrefix}/self_evaluation_implement/add`,
       qs.stringify(reqData)
     );
   },
   // 自评实施不分页列表
   self_evaluation_implement_list_all(reqData) {
     return axios.post(
       `${apiPrefix}/self_evaluation_implement/list/all`,
       qs.stringify(reqData)
     );
   },
   // 自评实施修改
   self_evaluation_implement_update(reqData) {
     return axios.post(
       `${apiPrefix}/self_evaluation_implement/update`,
       qs.stringify(reqData)
     );
   },
   // 自评实施删除
   self_evaluation_implement_del(reqData) {
     return axios.post(
       `${apiPrefix}/self_evaluation_implement/del`,
       qs.stringify(reqData)
     );
   },
   // 自评问题管理列表
   self_evaluation_problem_list(reqData) {
     return axios.post(
       `${apiPrefix}/self_evaluation_problem/list`,
       qs.stringify(reqData)
     );
   },
   // 自评问题管理详情
   self_evaluation_problem_query(reqData) {
     return axios.post(
       `${apiPrefix}/self_evaluation_problem/query`,
       qs.stringify(reqData)
     );
   },
   // 自评问题管理添加
   self_evaluation_problem_add(reqData) {
     return axios.post(
       `${apiPrefix}/self_evaluation_problem/add`,
       qs.stringify(reqData)
     );
   },
   // 自评问题管理修改
   self_evaluation_problem_update(reqData) {
     return axios.post(
       `${apiPrefix}/self_evaluation_problem/update`,
       qs.stringify(reqData)
     );
   },
   // 自评问题管理删除
   self_evaluation_problem_del(reqData) {
     return axios.post(
       `${apiPrefix}/self_evaluation_problem/del`,
       qs.stringify(reqData)
     );
   },
   // 自评问题管理修改问题追踪状态
   self_evaluation_problem_update_state(reqData) {
     return axios.post(
       `${apiPrefix}/self_evaluation_problem/update/state`,
       qs.stringify(reqData)
     );
   },

   // 安全监测
   // 监测站点类型列表
   safe_type_list(reqData) {
     return axios.post(`${apiPrefix}/safe/type/list`, qs.stringify(reqData));
   },
   // 监测站点列表
   safe_site_list(reqData) {
     return axios.post(`${apiPrefix}/safe/site/list`, qs.stringify(reqData));
   },
   // 监测站点详情
   safe_site_query(reqData) {
     return axios.post(`${apiPrefix}/safe/site/query`, qs.stringify(reqData));
   },
   // 监测站点添加
   safe_site_add(reqData) {
     return axios.post(`${apiPrefix}/safe/site/add`, qs.stringify(reqData));
   },
   // 监测站点修改
   safe_site_update(reqData) {
     return axios.post(`${apiPrefix}/safe/site/update`, qs.stringify(reqData));
   },
   // 监测站点删除
   safe_site_del(reqData) {
     return axios.post(`${apiPrefix}/safe/site/del`, qs.stringify(reqData));
   },
   // 站点设备列表
   safe_site_device_list(reqData) {
     return axios.post(
       `${apiPrefix}/safe/site/device/list`,
       qs.stringify(reqData)
     );
   },
   // 一级检测站点列表
   safe_supervise_site_list(reqData) {
     return axios.post(
       `${apiPrefix}/safe/supervise/site/list`,
       qs.stringify(reqData)
     );
   },
   // 二级监测列表
   safe_supervise_list(reqData) {
     return axios.post(
       `${apiPrefix}/safe/supervise/list`,
       qs.stringify(reqData)
     );
   },
   // 人工校对
   supervise_check(reqData) {
     return axios.post(
       `${apiPrefix}/safe/supervise/check`,
       qs.stringify(reqData)
     );
   },
   // 删除设备数据
   safe_supervise_del(reqData) {
     return axios.post(`${apiPrefix}/safe/supervise/del`, qs.stringify(reqData));
   },
   // 预警信息
   // 预警信息列表
   safe_log_list(reqData) {
     return axios.post(`${apiPrefix}/safe/log/list`, qs.stringify(reqData));
   },
   // 预警信息详情
   safe_log_query(reqData) {
     return axios.post(`${apiPrefix}/safe/log/query`, qs.stringify(reqData));
   },
   // 预警信息添加
   safe_log_add(reqData) {
     return axios.post(`${apiPrefix}/safe/log/add`, qs.stringify(reqData));
   },

   // 值班信息列表
   duty_information_list(reqData) {
     return axios.post(
       `${apiPrefix}/duty_information/list`,
       qs.stringify(reqData)
     );
   },
   // 值班信息详情
   duty_information_query(reqData) {
     return axios.post(
       `${apiPrefix}/duty_information/query`,
       qs.stringify(reqData)
     );
   },
   // 值班信息添加
   duty_information_add(reqData) {
     return axios.post(
       `${apiPrefix}/duty_information/add`,
       qs.stringify(reqData)
     );
   },
   // 值班信息修改
   duty_information_update(reqData) {
     return axios.post(
       `${apiPrefix}/duty_information/update`,
       qs.stringify(reqData)
     );
   },
   // 值班信息删除
   duty_information_del(reqData) {
     return axios.post(
       `${apiPrefix}/duty_information/del`,
       qs.stringify(reqData)
     );
   },
   // 档案分类列表
   record_type_list(reqData) {
     return axios.post(`${apiPrefix}/record_type/list`, qs.stringify(reqData));
   },
   // 档案分类详情
   record_type_query(reqData) {
     return axios.post(`${apiPrefix}/record_type/query`, qs.stringify(reqData));
   },
   // 档案分类添加
   record_type_add(reqData) {
     return axios.post(`${apiPrefix}/record_type/add`, qs.stringify(reqData));
   },
   // 档案分类修改
   record_type_update(reqData) {
     return axios.post(`${apiPrefix}/record_type/update`, qs.stringify(reqData));
   },
   // 档案分类删除
   record_type_del(reqData) {
     return axios.post(`${apiPrefix}/record_type/del`, qs.stringify(reqData));
   },
   // 电子档案列表
   record_electron_list(reqData) {
     return axios.post(
       `${apiPrefix}/record_electron/list`,
       qs.stringify(reqData)
     );
   },
   // 电子档案详情
   record_electron_query(reqData) {
     return axios.post(
       `${apiPrefix}/record_electron/query`,
       qs.stringify(reqData)
     );
   },
   // 电子档案添加
   record_electron_add(reqData) {
     return axios.post(
       `${apiPrefix}/record_electron/add`,
       qs.stringify(reqData)
     );
   },
   // 电子档案修改
   record_electron_update(reqData) {
     return axios.post(
       `${apiPrefix}/record_electron/update`,
       qs.stringify(reqData)
     );
   },
   // 电子档案删除
   record_electron_del(reqData) {
     return axios.post(
       `${apiPrefix}/record_electron/del`,
       qs.stringify(reqData)
     );
   },
   // 纸质档案列表
   record_paper_list(reqData) {
     return axios.post(`${apiPrefix}/record_paper/list`, qs.stringify(reqData));
   },
   // 纸质档案详情
   record_paper_query(reqData) {
     return axios.post(`${apiPrefix}/record_paper/query`, qs.stringify(reqData));
   },
   // 纸质档案添加
   record_paper_add(reqData) {
     return axios.post(`${apiPrefix}/record_paper/add`, qs.stringify(reqData));
   },
   // 纸质档案修改
   record_paper_update(reqData) {
     return axios.post(
       `${apiPrefix}/record_paper/update`,
       qs.stringify(reqData)
     );
   },
   // 纸质档案删除
   record_paper_del(reqData) {
     return axios.post(`${apiPrefix}/record_paper/del`, qs.stringify(reqData));
   },
   // 纸质档案出借记录列表
   record_paper_list_lend_record(reqData) {
     return axios.post(
       `${apiPrefix}/record_paper/list/lend_record`,
       qs.stringify(reqData)
     );
   },
   // 纸质档案出借记录添加
   record_paper_add_lend_record(reqData) {
     return axios.post(
       `${apiPrefix}/record_paper/add/lend_record`,
       qs.stringify(reqData)
     );
   },
   // 纸质档案出借记录修改
   record_paper_update_lend_record(reqData) {
     return axios.post(
       `${apiPrefix}/record_paper/update/lend_record`,
       qs.stringify(reqData)
     );
   },

   // 工程管理
   // 水美乡村片区提升工程列表
   area_upgrading_list(reqData) {
     return axios.post(
       `${apiPrefix}/area_upgrading/list`,
       qs.stringify(reqData)
     );
   },
   // 水美乡村片区提升工程添加
   area_upgrading_add(reqData) {
     return axios.post(`${apiPrefix}/area_upgrading/add`, qs.stringify(reqData));
   },
   // 水美乡村片区提升工程详情
   area_upgrading_query(reqData) {
     return axios.post(
       `${apiPrefix}/area_upgrading/query`,
       qs.stringify(reqData)
     );
   },
   // 水美乡村片区提升工程修改
   area_upgrading_update(reqData) {
     return axios.post(
       `${apiPrefix}/area_upgrading/update`,
       qs.stringify(reqData)
     );
   },
   // 水美乡村片区提升工程删除
   area_upgrading_del(reqData) {
     return axios.post(`${apiPrefix}/area_upgrading/del`, qs.stringify(reqData));
   },
   // 乡列表
   county_village_township_list(reqData) {
     return axios.post(
       `${apiPrefix}/county_village/township/list`,
       qs.stringify(reqData)
     );
   },
   // 破损山体修复工程列表
   repair_damaged_mountain_list(reqData) {
     return axios.post(
       `${apiPrefix}/repair_damaged_mountain/list`,
       qs.stringify(reqData)
     );
   },
   // 破损山体修复工程添加
   repair_damaged_mountain_add(reqData) {
     return axios.post(
       `${apiPrefix}/repair_damaged_mountain/add`,
       qs.stringify(reqData)
     );
   },
   // 破损山体修复工程详情
   repair_damaged_mountain_query(reqData) {
     return axios.post(
       `${apiPrefix}/repair_damaged_mountain/query`,
       qs.stringify(reqData)
     );
   },
   // 破损山体修复工程修改
   repair_damaged_mountain_update(reqData) {
     return axios.post(
       `${apiPrefix}/repair_damaged_mountain/update`,
       qs.stringify(reqData)
     );
   },
   // 破损山体修复工程删除
   repair_damaged_mountain_del(reqData) {
     return axios.post(
       `${apiPrefix}/repair_damaged_mountain/del`,
       qs.stringify(reqData)
     );
   },

   // PC首页图表数据 监测信息 河流水库名称
   river_river_reservoir_list(reqData) {
     return axios.post(
       `${apiPrefix}/river/river_reservoir_list`,
       qs.stringify(reqData)
     );
   },
   // PC首页图表数据 监测信息 站点PC列表
   safe_site_list_pc(reqData) {
     return axios.post(`${apiPrefix}/safe/site/list/pc`, qs.stringify(reqData));
   },
   // PC首页图表数据 监测信息 历史数据图表
   safe_realtime_history(reqData) {
     return axios.post(
       `${apiPrefix}/safe/realtime/history`,
       qs.stringify(reqData)
     );
   },

   // PC首页图表数据 待办事项
   index_dealt(reqData) {
     return axios.post(`${apiPrefix}/index/pc/dealt`, qs.stringify(reqData));
   },
   // PC首页图表数据 设备信息
   index_device(reqData) {
     return axios.post(`${apiPrefix}/index/pc/device`, qs.stringify(reqData));
   },
   // PC首页图表数据 工程信息
   index_pro(reqData) {
     return axios.post(`${apiPrefix}/index/pc/pro`, qs.stringify(reqData));
   },
   // PC首页图表数据 河湖信息
   index_river(reqData) {
     return axios.post(`${apiPrefix}/index/pc/river`, qs.stringify(reqData));
   },
   // PC首页图表数据 巡查
   index_bt_xc(reqData) {
     return axios.post(`${apiPrefix}/index/pc/bt/xc`, qs.stringify(reqData));
   },
   // PC首页图表数据 隐患处理
   index_bt_th(reqData) {
     return axios.post(`${apiPrefix}/index/pc/bt/yh`, qs.stringify(reqData));
   },
   // PC首页图表数据 调度任务
   index_bt_dd(reqData) {
     return axios.post(`${apiPrefix}/index/pc/bt/dd`, qs.stringify(reqData));
   },
   // unity全景图列表
   panorama_unity_list(reqData) {
     return axios.post(
       `${apiPrefix}/panorama/unity/list`,
       qs.stringify(reqData)
     );
   },
   // unity全景图添加
   panorama_unity_add(reqData) {
     return axios.post(`${apiPrefix}/panorama/unity/add`, qs.stringify(reqData));
   },
   // unity全景图修改
   panorama_unity_update(reqData) {
     return axios.post(
       `${apiPrefix}/panorama/unity/update`,
       qs.stringify(reqData)
     );
   },
   // unity全景图删除
   panorama_unity_del(reqData) {
     return axios.post(`${apiPrefix}/panorama/unity/del`, qs.stringify(reqData));
   },
   // 重置用户密码
   user_reset_password(reqData) {
     return axios.post(
       `${apiPrefix}/user/reset/password`,
       qs.stringify(reqData)
     );
   },
   // 验证码
   phone_code(reqData) {
     return axios.post(`${apiPrefix}/phone/code`, qs.stringify(reqData));
   },

   // Unity需要
   // 工程详情
   applet_project_query(reqData) {
     return axios.post(
       `${apiPrefix}/applet/project/query`,
       qs.stringify(reqData)
     );
   },

   //unity网页接口==========================================

   //获取行政区划
   u_getDivision(reqData) {
     return axios.post(
       `${apiPrefix}/unitywebpc/division`,
       qs.stringify(reqData)
     );
   },
   // 值班人员列表
   u_duty_informationList(reqData) {
     return axios.post(
       `${apiPrefix}/unitywebpc/duty_information/list`,
       qs.stringify(reqData)
     );
   },
   // 施工记录
   u_gcjl_unityengine(reqData) {
     return axios.post(
       `${apiPrefix}/unitywebpc/gcjl/unityengine`,
       qs.stringify(reqData)
     );
   },

   // 项目资源检索(河湖获取资源检索)
   u_getCheckRiver(reqData) {
     return axios.post(
       `${apiPrefix}/unitywebpc/lakeriver/check`,
       qs.stringify(reqData)
     );
   },
   //监测分析-实时监测
   u_monitor_monitor(reqData) {
     return axios.post(
       `${apiPrefix}/unitywebpc/monitor/monitor`,
       qs.stringify(reqData)
     );
   },
   //监测分析-实时状态
   u_monitor_realtime(reqData) {
     return axios.post(
       `${apiPrefix}/unitywebpc/monitor/realtime`,
       qs.stringify(reqData)
     );
   },
   // 监测分析-安全监测
   u_monitor_safe(reqData) {
     return axios.post(
       `${apiPrefix}/unitywebpc/monitor/safe`,
       qs.stringify(reqData)
     );
   },
   // 监测分析-安全监测/实时状态/实时监测（不用了）
   u_monitor(reqData) {
     return axios.post(`${apiPrefix}/unitywebpc/monitor`, qs.stringify(reqData));
   },
   // 监测分析-安全监测/实时状态/实时监测
   unityV2Point_monitor(reqData) {
     return axios.post(
       `${apiPrefix}/unityV2Point/monitor`,
       qs.stringify(reqData)
     );
   },
   // 项目资源检索(工程获取资源搜索)
   u_getCheckEngineer(reqData) {
     return axios.post(
       `${apiPrefix}/unitywebpc/project/check`,
       qs.stringify(reqData)
     );
   },
   //视频监控-详情
   u_getVideo(reqData) {
     return axios.post(
       `${apiPrefix}/unitywebpc/video/query`,
       qs.stringify(reqData)
     );
   },
   //智慧河湖-预警饼状图
   u_warn_chart(reqData) {
     return axios.post(
       `${apiPrefix}/unitywebpc/warn/chart`,
       qs.stringify(reqData)
     );
   },
   // 实时水位流量图表
   safet_realtime_table(reqData) {
     return axios.post(
       `${apiPrefix}/safe/realtime/table`,
       qs.stringify(reqData)
     );
   },
   // 降雨 雨量站查询
   u_site_type(reqData) {
     return axios.post(
       `${apiPrefix}/unitywebpc/site/type`,
       qs.stringify(reqData)
     );
   },
   // 控制面板-环境详情
   u_control_environment(reqData) {
     return axios.post(
       `${apiPrefix}/unitywebpc/control_panel/environment`,
       qs.stringify(reqData)
     );
   },
   // 控制面板-水质详情
   u_control_waterquality(reqData) {
     return axios.post(
       `${apiPrefix}/unitywebpc/control_panel/waterquality`,
       qs.stringify(reqData)
     );
   },
   // 控制面板-水质监测点详情
   u_control_site_query_shuizhi(reqData) {
     return axios.post(
       `${apiPrefix}/unitywebpc/control_panel/waterquality/new`,
       qs.stringify(reqData)
     );
   },
   // 控制面板-流量监测点详情
   u_control_site_query_liuliang(reqData) {
     return axios.post(
       `${apiPrefix}/unitywebpc/control_panel/waterflow/new`,
       qs.stringify(reqData)
     );
   },
   // 控制面板-水位监测点详情
   u_control_site_query_shuiwei(reqData) {
     return axios.post(
       `${apiPrefix}/unitywebpc/control_panel/waterlevel/new`,
       qs.stringify(reqData)
     );
   },
   // 控制面板-雨量监测点详情
   u_control_site_query_yuliang(reqData) {
     return axios.post(
       `${apiPrefix}/unitywebpc/control_panel/waterrain/new`,
       qs.stringify(reqData)
     );
   },
   // 控制面板-运行监测点详情
   u_control_site_query_yunxing(reqData) {
     return axios.post(
       `${apiPrefix}/unitywebpc/control_panel/waterrun/new`,
       qs.stringify(reqData)
     );
   },

   // 控制面板-监测点详情 新接口
   u_smxc_safe_config_query(reqData) {
     return axios.post(
       `${apiPrefix}/v2/safe/config/unity/query`,
       qs.stringify(reqData)
     );
   },
   // 月降雨量 折线图新接口
   u_month_water(reqData) {
     return axios.post(
       `${apiPrefix}/unitywebpc/month/water`,
       qs.stringify(reqData)
     );
   },
   // 日降雨量 散点图新接口
   u_day_water(reqData) {
     return axios.post(
       `${apiPrefix}/unitywebpc/day/water`,
       qs.stringify(reqData)
     );
   },
   // 设备详情 图表新接口
   u_device_date(reqData) {
     return axios.post(
       `${apiPrefix}/unitywebpc/device/date`,
       qs.stringify(reqData)
     );
   },
   // 水位 图表新接口
   u_river_water_level(reqData) {
     return axios.post(
       `${apiPrefix}/index/river_water/level`,
       qs.stringify(reqData)
     );
   },
   // 设备详情右侧旋转 新接口
   u_equipment_panorama_list(reqData) {
     return axios.post(
       `${apiPrefix}/equipment/panorama/list`,
       qs.stringify(reqData)
     );
   },

   // 获取日降水和月降水图表
   u_table_rain(reqData) {
     return axios.post(
       `${apiPrefix}/unitywebpc/table/rain`,
       qs.stringify(reqData)
     );
   },

   // 河湖想请获取水位和流量
   applet_river_query(reqData) {
     return axios.post(`${apiPrefix}/applet/river/query`, qs.stringify(reqData));
   },
   //视频监控2-详情
   u_getVideo2(reqData) {
     return axios.post(`${apiPrefix}/video/query`, qs.stringify(reqData));
   },
   //视频监控2-获取kit
   video_get_kit(reqData) {
     return axios.post(`${apiPrefix}/video/get/kit`, qs.stringify(reqData));
   },

   // 智慧防汛 资源检索 列表
   u_getCheckFx(reqData) {
     return axios.post(
       `${apiPrefix}/unitywebpc/fx/check`,
       qs.stringify(reqData)
     );
   },

   // 新 工程详情
   project_items_query(reqData) {
     return axios.post(
       `${apiPrefix}/unitywebpc/project/items/query`,
       qs.stringify(reqData)
     );
   },
   // 新 预警列表
   safe_log_list_new(reqData) {
     return axios.post(`${apiPrefix}/safe/log/list/new`, qs.stringify(reqData));
   },
   // 新 预警列表
   u_device_monitor_list(reqData) {
     return axios.post(
       `${apiPrefix}/equipment_point_new/monitor`,
       qs.stringify(reqData)
     );
   },
   // 新 站点类型列表
   u_site_type_list(reqData) {
     return axios.post(
       `${apiPrefix}/unity/v3/monitor/type`,
       qs.stringify(reqData)
     );
   },
   // 新 预警列表
   v2_warn_list_page(reqData) {
     return axios.post(`${apiPrefix}/v2/warn/list/page`, qs.stringify(reqData));
   },
   // 新 预警详情
   v2_warn_query(reqData) {
     return axios.post(`${apiPrefix}/v2/warn/query`, qs.stringify(reqData));
   },
   // 站点列表不分页
   v2_safe_list(reqData) {
     return axios.post(`${apiPrefix}/v2/safe/list`, qs.stringify(reqData));
   },
   // 站点列表不分页
   unity_config_query(reqData) {
     return axios.post(`${apiPrefix}/unity/config/query`, qs.stringify(reqData));
   }, */

  //值班管理--列表
  duty_list(reqData) {
    return axios.post(`${apiPrefix}/duty/list`, qs.stringify(reqData));
  },
  /*  //获取token
    u_getToken(reqData) {
      return axios.post(
        `${apiPrefix}/unitywebpc/get/token`,
        qs.stringify(reqData)
      );
    },*/
  //设备监测--数据
  yw_site_type(reqData) {
    return axios.post(`${apiPrefix}/yw/site/type`, qs.stringify(reqData));
  },
  //设备监测--图表
  yw_site_data(reqData) {
    return axios.post(`${apiPrefix}/yw/site/data`, qs.stringify(reqData));
  },
  //洪水预测
  storageCurveGetLevel(reqData) {
    return axios.post(
      `${apiPrefix}/storage_curve/get/level`,
      qs.stringify(reqData)
    );
  },
  //设备监测/大坝变形
  device_monitor_table(reqData) {
    return axios.post(
      `${apiPrefix}/device/monitor/table`,
      qs.stringify(reqData)
    );
  },

  //大坝渗流--数据图表
  device_realtime_table(reqData) {
    return axios.post(
      `${apiPrefix}/device/realtime/table`,
      qs.stringify(reqData)
    );
  },
  //大坝渗流--弹窗历史数据图表
  device_site_table(reqData) {
    return axios.post(`${apiPrefix}/device/site/table`, qs.stringify(reqData));
  },

  // 放水洞倾斜
  mhsk_device_fsd_tilt(reqData) {
    return axios.post(`${apiPrefix}/device/fsd/tilt`, qs.stringify(reqData));
  }
};

export default Api;
